<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
<meta name="viewport" content="width=device-width">
<meta name="theme-color" content="#222">
<meta name="generator" content="Hexo 5.4.0">


  <link rel="icon" type="image/png" sizes="16x16" href="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/avatar.jpg">

<link rel="stylesheet" href="/next/css/main.css">



<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fortawesome/fontawesome-free@5.15.3/css/all.min.css" integrity="sha256-2H3fkXt6FEmrReK448mDVGKb3WW2ZZw35gI7vqHOE4Y=" crossorigin="anonymous">
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/animate.css@3.1.1/animate.min.css" integrity="sha256-PR7ttpcvz8qrF57fur/yAx1qXMFJeJFiA6pSzWi0OIE=" crossorigin="anonymous">
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3.5.7/dist/jquery.fancybox.min.css" integrity="sha256-Vzbj7sDDS/woiFS3uNKo8eIuni59rjyNGtXfstRzStA=" crossorigin="anonymous">

<script class="next-config" data-name="main" type="application/json">{"hostname":"cnhuazhu.gitee.io","root":"/next/","images":"/next/images","scheme":"Mist","version":"8.6.1","exturl":false,"sidebar":{"position":"left","Muse | Mist":320,"display":"post","padding":18,"offset":12},"copycode":true,"bookmark":{"enable":false,"color":"#222","save":"auto"},"fancybox":true,"mediumzoom":true,"lazyload":false,"pangu":false,"comments":{"style":"tabs","active":null,"storage":true,"lazyload":false,"nav":null},"motion":{"enable":true,"async":false,"transition":{"post_block":"fadeIn","post_header":"fadeInDown","post_body":"fadeInDown","coll_header":"fadeInLeft","sidebar":"fadeInUp"}},"prism":false,"i18n":{"placeholder":"搜索...","empty":"没有找到任何搜索结果：${query}","hits_time":"找到 ${hits} 个搜索结果（用时 ${time} 毫秒）","hits":"找到 ${hits} 个搜索结果"},"path":"/next/search.xml","localsearch":{"enable":true,"trigger":"auto","top_n_per_article":1,"unescape":false,"preload":false}}</script><script src="/next/js/config.js"></script>
<meta name="description" content="记录操作系统学习历程">
<meta property="og:type" content="article">
<meta property="og:title" content="操作系统学习笔记-虚拟内存">
<meta property="og:url" content="https://cnhuazhu.gitee.io/next/2021/05/24/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98/index.html">
<meta property="og:site_name" content="花猪のBlog">
<meta property="og:description" content="记录操作系统学习历程">
<meta property="og:locale" content="zh_CN">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E5%88%86%E9%A1%B5%E9%A1%B9.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%88%86%E9%A1%B5%E5%9C%B0%E5%9D%80%E8%BD%AC%E6%8D%A2%E7%B3%BB%E7%BB%9F.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E4%B8%A4%E7%BA%A7%E5%B1%82%E6%AC%A1%E9%A1%B5%E8%A1%A8.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E4%B8%A4%E7%BA%A7%E5%B1%82%E6%AC%A1%E9%A1%B5%E8%A1%A8%E7%9A%84%E5%9C%B0%E5%9D%80%E8%BD%AC%E6%8D%A2.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%80%92%E6%8E%92%E9%A1%B5%E8%A1%A8.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%BD%AC%E7%A7%BB%E5%90%8E%E5%A4%87%E7%BC%93%E5%86%B2%E5%99%A8.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%BD%AC%E7%A7%BB%E5%90%8E%E5%A4%87%E7%BC%93%E5%86%B2%E5%99%A8%E6%B5%81%E7%A8%8B.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%99%9A%E5%AD%98%E4%B8%8E%E9%AB%98%E9%80%9F%E7%BC%93%E5%AD%98%E4%BA%A4%E4%BA%92.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E9%A1%B5%E5%B0%BA%E5%AF%B8%E7%9A%84%E5%BD%B1%E5%93%8D.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E8%A1%A8%E7%9A%84%E7%BB%93%E6%9E%84.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E7%9A%84%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E5%88%B0%E7%89%A9%E7%90%86%E5%9C%B0%E5%9D%80%E7%9A%84%E8%BD%AC%E6%8D%A2.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E9%A1%B5%E5%BC%8F%E8%A1%A8%E9%A1%B9.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E9%A1%B5%E5%BC%8F%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E8%BD%AC%E7%89%A9%E7%90%86%E5%9C%B0%E5%9D%80.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS保护与共享.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%97%B6%E9%92%9F%E7%AD%96%E7%95%A5%E7%BD%AE%E6%8D%A2.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E7%BD%AE%E6%8D%A2%E7%AD%96%E7%95%A5%E5%AE%9E%E4%BE%8B.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%9B%9B%E7%A7%8D%E7%BD%AE%E6%8D%A2%E7%AE%97%E6%B3%95%E7%9A%84%E5%AE%9E%E9%AA%8C.png">
<meta property="og:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%B9%B6%E5%8F%91%E5%BA%A6%E5%A4%A7%E5%B0%8F.png">
<meta property="article:published_time" content="2021-05-24T07:19:30.000Z">
<meta property="article:modified_time" content="2021-06-30T13:04:50.609Z">
<meta property="article:author" content="花猪">
<meta property="article:tag" content="操作系统">
<meta name="twitter:card" content="summary">
<meta name="twitter:image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E5%88%86%E9%A1%B5%E9%A1%B9.png">


<link rel="canonical" href="https://cnhuazhu.gitee.io/next/2021/05/24/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98/">



<script class="next-config" data-name="page" type="application/json">{"sidebar":"","isHome":false,"isPost":true,"lang":"zh-CN","comments":true,"permalink":"https://cnhuazhu.gitee.io/next/2021/05/24/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98/","path":"2021/05/24/操作系统/操作系统学习笔记-虚拟内存/","title":"操作系统学习笔记-虚拟内存"}</script>

<script class="next-config" data-name="calendar" type="application/json">""</script>
<title>操作系统学习笔记-虚拟内存 | 花猪のBlog</title>
  




  <noscript>
    <link rel="stylesheet" href="/next/css/noscript.css">
  </noscript>
</head>

<body itemscope itemtype="http://schema.org/WebPage" class="use-motion">
  <div class="headband"></div>

  <main class="main">
    <header class="header" itemscope itemtype="http://schema.org/WPHeader">
      <div class="header-inner"><div class="site-brand-container">
  <div class="site-nav-toggle">
    <div class="toggle" aria-label="切换导航栏" role="button">
        <span class="toggle-line"></span>
        <span class="toggle-line"></span>
        <span class="toggle-line"></span>
    </div>
  </div>

  <div class="site-meta">

    <a href="/next/" class="brand" rel="start">
      <i class="logo-line"></i>
      <h1 class="site-title">花猪のBlog</h1>
      <i class="logo-line"></i>
    </a>
  </div>

  <div class="site-nav-right">
    <div class="toggle popup-trigger">
        <i class="fa fa-search fa-fw fa-lg"></i>
    </div>
  </div>
</div>



<nav class="site-nav">
  <ul class="main-menu menu">
        <li class="menu-item menu-item-主站"><a href="https://cnhuazhu.top/" rel="noopener" target="_blank"><i class="fas fa-chevron-right fa-fw"></i>主站</a></li>
        <li class="menu-item menu-item-home"><a href="/next/" rel="section"><i class="fa fa-home fa-fw"></i>首页</a></li>
        <li class="menu-item menu-item-tags"><a href="/next/tags/" rel="section"><i class="fa fa-tags fa-fw"></i>标签<span class="badge">14</span></a></li>
        <li class="menu-item menu-item-categories"><a href="/next/categories/" rel="section"><i class="fa fa-th fa-fw"></i>分类<span class="badge">8</span></a></li>
        <li class="menu-item menu-item-archives"><a href="/next/archives/" rel="section"><i class="fa fa-archive fa-fw"></i>归档<span class="badge">53</span></a></li>
      <li class="menu-item menu-item-search">
        <a role="button" class="popup-trigger"><i class="fa fa-search fa-fw"></i>搜索
        </a>
      </li>
  </ul>
</nav>



  <div class="search-pop-overlay">
    <div class="popup search-popup"><div class="search-header">
  <span class="search-icon">
    <i class="fa fa-search"></i>
  </span>
  <div class="search-input-container">
    <input autocomplete="off" autocapitalize="off" maxlength="80"
           placeholder="搜索..." spellcheck="false"
           type="search" class="search-input">
  </div>
  <span class="popup-btn-close" role="button">
    <i class="fa fa-times-circle"></i>
  </span>
</div>
<div class="search-result-container no-result">
  <div class="search-result-icon">
    <i class="fa fa-spinner fa-pulse fa-5x"></i>
  </div>
</div>

    </div>
  </div>

</div>
        
  
  <div class="toggle sidebar-toggle" role="button">
    <span class="toggle-line"></span>
    <span class="toggle-line"></span>
    <span class="toggle-line"></span>
  </div>

  <aside class="sidebar">

    <div class="sidebar-inner sidebar-nav-active sidebar-toc-active">
      <ul class="sidebar-nav">
        <li class="sidebar-nav-toc">
          文章目录
        </li>
        <li class="sidebar-nav-overview">
          站点概览
        </li>
      </ul>

      <div class="sidebar-panel-container">
        <!--noindex-->
        <div class="post-toc-wrap sidebar-panel">
            <div class="post-toc animated"><ol class="nav"><li class="nav-item nav-level-1"><a class="nav-link" href="#%E5%89%8D%E8%A8%80"><span class="nav-number">1.</span> <span class="nav-text">前言</span></a></li><li class="nav-item nav-level-1"><a class="nav-link" href="#%E7%AC%AC%E5%85%AB%E7%AB%A0%EF%BC%9A%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98"><span class="nav-number">2.</span> <span class="nav-text">第八章：虚拟内存</span></a><ol class="nav-child"><li class="nav-item nav-level-2"><a class="nav-link" href="#%E7%A1%AC%E4%BB%B6%E5%92%8C%E6%8E%A7%E5%88%B6%E7%BB%93%E6%9E%84"><span class="nav-number">2.1.</span> <span class="nav-text">硬件和控制结构</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%B1%80%E9%83%A8%E6%80%A7%E5%92%8C%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98"><span class="nav-number">2.1.1.</span> <span class="nav-text">局部性和虚拟内存</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%88%86%E9%A1%B5"><span class="nav-number">2.1.2.</span> <span class="nav-text">分页</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#%E9%A1%B5%E8%A1%A8"><span class="nav-number">2.1.2.1.</span> <span class="nav-text">页表</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E4%B8%A4%E7%BA%A7%E5%B1%82%E6%AC%A1%E9%A1%B5%E8%A1%A8"><span class="nav-number">2.1.2.2.</span> <span class="nav-text">两级层次页表</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E5%8F%8D%E5%90%91%E9%A1%B5%E8%A1%A8-%E5%80%92%E6%8E%92%E9%A1%B5%E8%A1%A8"><span class="nav-number">2.1.2.3.</span> <span class="nav-text">反向页表&#x2F;倒排页表</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E8%BD%AC%E7%A7%BB%E5%90%8E%E5%A4%87%E7%BC%93%E5%86%B2%E5%99%A8-%E6%97%81%E8%A7%86%E7%BC%93%E5%86%B2%E5%99%A8"><span class="nav-number">2.1.2.4.</span> <span class="nav-text">转移后备缓冲器&#x2F;旁视缓冲器</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E9%A1%B5%E5%B0%BA%E5%AF%B8"><span class="nav-number">2.1.2.5.</span> <span class="nav-text">页尺寸</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%88%86%E6%AE%B5"><span class="nav-number">2.1.3.</span> <span class="nav-text">分段</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%AE%B5%E9%A1%B5%E5%BC%8F"><span class="nav-number">2.1.4.</span> <span class="nav-text">段页式</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E4%BF%9D%E6%8A%A4%E5%92%8C%E5%85%B1%E4%BA%AB"><span class="nav-number">2.1.5.</span> <span class="nav-text">保护和共享</span></a></li></ol></li><li class="nav-item nav-level-2"><a class="nav-link" href="#%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E8%BD%AF%E4%BB%B6"><span class="nav-number">2.2.</span> <span class="nav-text">操作系统软件</span></a><ol class="nav-child"><li class="nav-item nav-level-3"><a class="nav-link" href="#%E8%AF%BB%E5%8F%96%E7%AD%96%E7%95%A5"><span class="nav-number">2.2.1.</span> <span class="nav-text">读取策略</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%94%BE%E7%BD%AE%E7%AD%96%E7%95%A5"><span class="nav-number">2.2.2.</span> <span class="nav-text">放置策略</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E7%BD%AE%E6%8D%A2%E7%AD%96%E7%95%A5"><span class="nav-number">2.2.3.</span> <span class="nav-text">置换策略</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E9%A1%B5%E6%A1%86%E9%94%81%E5%AE%9A"><span class="nav-number">2.2.4.</span> <span class="nav-text">页框锁定</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#%E6%9C%80%E4%BD%B3%EF%BC%88OPT%EF%BC%89"><span class="nav-number">2.2.4.1.</span> <span class="nav-text">最佳（OPT）</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E6%9C%80%E8%BF%91%E6%9C%80%E5%B0%91%E4%BD%BF%E7%94%A8%EF%BC%88LRU%EF%BC%89"><span class="nav-number">2.2.4.2.</span> <span class="nav-text">最近最少使用（LRU）</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E5%85%88%E8%BF%9B%E5%85%88%E5%87%BA%EF%BC%88FIFO%EF%BC%89"><span class="nav-number">2.2.4.3.</span> <span class="nav-text">先进先出（FIFO）</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E6%97%B6%E9%92%9F%E7%AD%96%E7%95%A5%EF%BC%88Clock%EF%BC%89"><span class="nav-number">2.2.4.4.</span> <span class="nav-text">时钟策略（Clock）</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E5%A2%9E%E5%BC%BA%E5%9E%8B%E6%97%B6%E9%92%9F"><span class="nav-number">2.2.4.5.</span> <span class="nav-text">增强型时钟</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E9%A1%B5%E7%BC%93%E5%86%B2"><span class="nav-number">2.2.4.6.</span> <span class="nav-text">页缓冲</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E9%AB%98%E9%80%9F%E7%BC%93%E5%AD%98"><span class="nav-number">2.2.4.7.</span> <span class="nav-text">高速缓存</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E9%A9%BB%E7%95%99%E9%9B%86%E7%AE%A1%E7%90%86"><span class="nav-number">2.2.5.</span> <span class="nav-text">驻留集管理</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#%E9%A9%BB%E7%95%99%E9%9B%86%E5%A4%A7%E5%B0%8F"><span class="nav-number">2.2.5.1.</span> <span class="nav-text">驻留集大小</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E7%BD%AE%E6%8D%A2%E8%8C%83%E5%9B%B4"><span class="nav-number">2.2.5.2.</span> <span class="nav-text">置换范围</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E5%9B%BA%E5%AE%9A%E5%88%86%E9%85%8D%E3%80%81%E5%B1%80%E9%83%A8%E7%BD%AE%E6%8D%A2"><span class="nav-number">2.2.5.3.</span> <span class="nav-text">固定分配、局部置换</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E5%8F%AF%E5%8F%98%E5%88%86%E9%85%8D%E3%80%81%E5%85%A8%E5%B1%80%E7%BD%AE%E6%8D%A2"><span class="nav-number">2.2.5.4.</span> <span class="nav-text">可变分配、全局置换</span></a></li><li class="nav-item nav-level-4"><a class="nav-link" href="#%E5%8F%AF%E5%8F%98%E5%88%86%E9%85%8D%E3%80%81%E5%B1%80%E9%83%A8%E7%BD%AE%E6%8D%A2"><span class="nav-number">2.2.5.5.</span> <span class="nav-text">可变分配、局部置换</span></a></li></ol></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E6%B8%85%E9%99%A4%E7%AD%96%E7%95%A5"><span class="nav-number">2.2.6.</span> <span class="nav-text">清除策略</span></a></li><li class="nav-item nav-level-3"><a class="nav-link" href="#%E5%8A%A0%E8%BD%BD%E6%8E%A7%E5%88%B6"><span class="nav-number">2.2.7.</span> <span class="nav-text">加载控制</span></a><ol class="nav-child"><li class="nav-item nav-level-4"><a class="nav-link" href="#%E8%BF%9B%E7%A8%8B%E6%8C%82%E8%B5%B7"><span class="nav-number">2.2.7.1.</span> <span class="nav-text">进程挂起</span></a></li></ol></li></ol></li></ol></li><li class="nav-item nav-level-1"><a class="nav-link" href="#%E5%90%8E%E8%AE%B0"><span class="nav-number">3.</span> <span class="nav-text">后记</span></a></li></ol></div>
        </div>
        <!--/noindex-->

        <div class="site-overview-wrap sidebar-panel">
          <div class="site-overview">
            <div class="site-author site-overview-item animated" itemprop="author" itemscope itemtype="http://schema.org/Person">
    <img class="site-author-image" itemprop="image" alt="花猪"
      src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/avatar.jpg">
  <p class="site-author-name" itemprop="name">花猪</p>
  <div class="site-description" itemprop="description">为了获得不同的阅读体验，建立此分站。<br>（可在导航栏搜索想要查看的文章）<br><br>本站主题：NEXT 8.6.1</div>
</div>
<div class="site-state-wrap site-overview-item animated">
  <nav class="site-state">
      <div class="site-state-item site-state-posts">
          <a href="/next/archives/">
        
          <span class="site-state-item-count">53</span>
          <span class="site-state-item-name">日志</span>
        </a>
      </div>
      <div class="site-state-item site-state-categories">
            <a href="/next/categories/">
          
        <span class="site-state-item-count">8</span>
        <span class="site-state-item-name">分类</span></a>
      </div>
      <div class="site-state-item site-state-tags">
            <a href="/next/tags/">
          
        <span class="site-state-item-count">14</span>
        <span class="site-state-item-name">标签</span></a>
      </div>
  </nav>
</div>
  <div class="links-of-author site-overview-item animated">
      <span class="links-of-author-item">
        <a href="https://github.com/CNhuazhu" title="GitHub → https:&#x2F;&#x2F;github.com&#x2F;CNhuazhu" rel="noopener" target="_blank"><i class="fab fa-github fa-fw"></i>GitHub</a>
      </span>
  </div>



          </div>
        </div>
      </div>
    </div>
  </aside>
  <div class="sidebar-dimmer"></div>


    </header>

    
  <div class="back-to-top" role="button" aria-label="返回顶部">
    <i class="fa fa-arrow-up"></i>
    <span>0%</span>
  </div>
  <div class="reading-progress-bar"></div>

  <a href="https://github.com/CNhuazhu" class="github-corner" title="Follow me on GitHub" aria-label="Follow me on GitHub" rel="noopener" target="_blank"><svg width="80" height="80" viewBox="0 0 250 250" aria-hidden="true"><path d="M0,0 L115,115 L130,115 L142,142 L250,250 L250,0 Z"></path><path d="M128.3,109.0 C113.8,99.7 119.0,89.6 119.0,89.6 C122.0,82.7 120.5,78.6 120.5,78.6 C119.2,72.0 123.4,76.3 123.4,76.3 C127.3,80.9 125.5,87.3 125.5,87.3 C122.9,97.6 130.6,101.9 134.4,103.2" fill="currentColor" style="transform-origin: 130px 106px;" class="octo-arm"></path><path d="M115.0,115.0 C114.9,115.1 118.7,116.5 119.8,115.4 L133.7,101.6 C136.9,99.2 139.9,98.4 142.2,98.6 C133.8,88.0 127.5,74.4 143.8,58.0 C148.5,53.4 154.0,51.2 159.7,51.0 C160.3,49.4 163.2,43.6 171.4,40.1 C171.4,40.1 176.1,42.5 178.8,56.2 C183.1,58.6 187.2,61.8 190.9,65.4 C194.5,69.0 197.7,73.2 200.1,77.6 C213.8,80.2 216.3,84.9 216.3,84.9 C212.7,93.1 206.9,96.0 205.4,96.6 C205.1,102.4 203.0,107.8 198.3,112.5 C181.9,128.9 168.3,122.5 157.7,114.1 C157.9,116.9 156.7,120.9 152.7,124.9 L141.0,136.5 C139.8,137.7 141.6,141.9 141.8,141.8 Z" fill="currentColor" class="octo-body"></path></svg></a>

<noscript>
  <div class="noscript-warning">Theme NexT works best with JavaScript enabled</div>
</noscript>


    <div class="main-inner post posts-expand">


  


<div class="post-block">
  
  

  <article itemscope itemtype="http://schema.org/Article" class="post-content" lang="zh-CN">
    <link itemprop="mainEntityOfPage" href="https://cnhuazhu.gitee.io/next/2021/05/24/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98/">

    <span hidden itemprop="author" itemscope itemtype="http://schema.org/Person">
      <meta itemprop="image" content="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/avatar.jpg">
      <meta itemprop="name" content="花猪">
      <meta itemprop="description" content="为了获得不同的阅读体验，建立此分站。<br>（可在导航栏搜索想要查看的文章）<br><br>本站主题：NEXT 8.6.1">
    </span>

    <span hidden itemprop="publisher" itemscope itemtype="http://schema.org/Organization">
      <meta itemprop="name" content="花猪のBlog">
    </span>
      <header class="post-header">
        <h1 class="post-title" itemprop="name headline">
          操作系统学习笔记-虚拟内存
        </h1>

        <div class="post-meta-container">
          <div class="post-meta">
    <span class="post-meta-item">
      <span class="post-meta-item-icon">
        <i class="far fa-calendar"></i>
      </span>
      <span class="post-meta-item-text">发表于</span>

      <time title="创建时间：2021-05-24 15:19:30" itemprop="dateCreated datePublished" datetime="2021-05-24T15:19:30+08:00">2021-05-24</time>
    </span>
      <span class="post-meta-item">
        <span class="post-meta-item-icon">
          <i class="far fa-calendar-check"></i>
        </span>
        <span class="post-meta-item-text">更新于</span>
        <time title="修改时间：2021-06-30 21:04:50" itemprop="dateModified" datetime="2021-06-30T21:04:50+08:00">2021-06-30</time>
      </span>
    <span class="post-meta-item">
      <span class="post-meta-item-icon">
        <i class="far fa-folder"></i>
      </span>
      <span class="post-meta-item-text">分类于</span>
        <span itemprop="about" itemscope itemtype="http://schema.org/Thing">
          <a href="/next/categories/%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0/" itemprop="url" rel="index"><span itemprop="name">学习笔记</span></a>
        </span>
    </span>

  
    <span id="/next/2021/05/24/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98/" class="post-meta-item leancloud_visitors" data-flag-title="操作系统学习笔记-虚拟内存" title="阅读次数">
      <span class="post-meta-item-icon">
        <i class="far fa-eye"></i>
      </span>
      <span class="post-meta-item-text">阅读次数：</span>
      <span class="leancloud-visitors-count"></span>
    </span>
    <span id="/next/2021/05/24/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E8%99%9A%E6%8B%9F%E5%86%85%E5%AD%98/" class="post-meta-item twikoo_visitors" data-flag-title="操作系统学习笔记-虚拟内存" title="阅读次数">
      <span class="post-meta-item-icon">
        <i class="far fa-eye"></i>
      </span>
      <span class="post-meta-item-text">阅读次数：</span>
      <span id="twikoo_visitors"></span>
    </span>
  
      </div>
      <div class="post-meta">
    <span class="post-meta-item" title="本文字数">
      <span class="post-meta-item-icon">
        <i class="far fa-file-word"></i>
      </span>
      <span class="post-meta-item-text">本文字数：</span>
      <span>12k</span>
    </span>
    <span class="post-meta-item" title="阅读时长">
      <span class="post-meta-item-icon">
        <i class="far fa-clock"></i>
      </span>
      <span class="post-meta-item-text">阅读时长 &asymp;</span>
      <span>11 分钟</span>
    </span>
</div>

            <div class="post-description">记录操作系统学习历程</div>
        </div>
      </header>

    
    
    
    <div class="post-body" itemprop="articleBody">
        <h1 id="前言"><a href="#前言" class="headerlink" title="前言"></a>前言</h1><p><em>正在学习操作系统，记录笔记。</em></p>
<blockquote>
<p>参考资料：</p>
<p>《操作系统（精髓与设计原理 第8版） 》</p>
</blockquote>
<hr>
<h1 id="第八章：虚拟内存"><a href="#第八章：虚拟内存" class="headerlink" title="第八章：虚拟内存"></a>第八章：虚拟内存</h1><p>在正式开始前先介绍一下本章要用到的术语：</p>
<table>
<thead>
<tr>
<th>术语</th>
<th>解释</th>
</tr>
</thead>
<tbody><tr>
<td>虚拟内存（Virtual memory）</td>
<td>一种存储器分配方案，在这种分配方案中，辅助存储器可以被寻址，就好像它是主存储器的一部分一样。程序可用于引用内存的地址与内存系统用于标识物理存储站点的地址相区别，程序生成的地址自动转换为相应的机器地址。虚拟存储器的大小受到计算机系统寻址方案和可用辅助存储器数量的限制，而不受主存储器位置的实际数量的限制</td>
</tr>
<tr>
<td>虚拟地址（Virtual address）</td>
<td>在虚拟内存中分配给某一位置的地址，它使得该位置可被访问，就好像是主存的一部分那样</td>
</tr>
<tr>
<td>虚拟地址空间（Virtual address space）</td>
<td>分配给进程的虚拟存储</td>
</tr>
<tr>
<td>地址空间（Address space）</td>
<td>用于某进程的内存地址范围</td>
</tr>
<tr>
<td>实地址（Real address）</td>
<td>内存中存储位置的地址</td>
</tr>
</tbody></table>
<h2 id="硬件和控制结构"><a href="#硬件和控制结构" class="headerlink" title="硬件和控制结构"></a>硬件和控制结构</h2><p>由上一章我们可以了解到分页和分段机制在内存管理中取得的根本性突破：</p>
<ul>
<li>进程中的所有内存访问都是逻辑地址，这些逻辑地址会在运行时动态地转换为物理地址。这意味着一个进程可被换入或换出内存，因此进程可在执行过程的不同时刻占据内存中的不同区域。</li>
<li>一个进程可划分为许多块（页和段），在执行过程中，这些块不需要连续地位于内存中。</li>
</ul>
<p>那么我们由此可以思考：如果保有上述这两个特点，在程序执行中，不需要进程的所有部分（页或段）都被加载到内存中，如果内存中保存有待取的下一条指令的所在块（页或段）以及待访问的下一个数据单元所在的块，那么进程可以持续运行下去。</p>
<p>接着就来描述一下程序如何以这样的方式在内存中运行：</p>
<ul>
<li><p>一个新进程被载入内存，操作系统在最初只是载入新程序最开处的一个或几个块（页或段），而非全部。</p>
</li>
<li><p><strong>常驻集：</strong>进程执行的任何时候都在内存的部分称为进程的常驻集。</p>
<p>只要所有内存访问都是访问常驻集中的单元，执行就可以顺利进行。</p>
</li>
<li><p>当处理器需要访问一个不在内存中的逻辑地址时：</p>
<ul>
<li>会产生一个中断（缺页中断），即出现了内存访问故障。</li>
<li>操作系统会将此进程置于阻塞态。</li>
</ul>
</li>
<li><p>操作系统会把包含引发访问故障的逻辑地址的进程块读入内存，具体流程如下：</p>
<ul>
<li>操作系统产生一个磁盘I/O读请求。</li>
<li>在执行磁盘I/O期间，操作系统可以调度另一个进程运行。</li>
<li>当需要的块读入内存后，再产生一个中断，操作系统把之前由于缺少进程块而被阻塞的进程置位就绪态。</li>
</ul>
</li>
<li><p>进程继续执行。</p>
</li>
</ul>
<p>这种执行进程的策略有以下优点（暂且不考虑由于中断、载入新块所带来的效率影响）：</p>
<ul>
<li>在内存中保留多个进程：<ul>
<li>对于任何特定进程，都只载入某些部分到内存中，这样内存会有足够的空间运行多个进程。</li>
<li>由于内存中存在的进程数量增加，那么在任意时刻总会有至少一个进程处于就绪态，进而使得处理器没有闲置状态，提高了效率。</li>
</ul>
</li>
<li>支持运行大于主存的程序：<ul>
<li>大程序可以分成小块，通过某种覆盖策略分别加载。（基于分段或分页的虚拟内存）</li>
</ul>
</li>
</ul>
<p><strong>实存储器</strong>（简称：实存，real memory）：就是主存（main memory），进程只能在此运行。</p>
<p><strong>虚拟内存</strong>（简称：虚存，virtual memory）：</p>
<ul>
<li>通常分配在磁盘上</li>
<li>支持更有效的系统并发度</li>
<li>可以解除用户与内存之间没有必要的紧密约束</li>
</ul>
<blockquote>
<p>下表总结了使用和不使用虚存情况下分页和分段的特点：</p>
<table>
<thead>
<tr>
<th>简单分页</th>
<th>虚存分页</th>
<th>简单分段</th>
<th>虚存分段</th>
</tr>
</thead>
<tbody><tr>
<td>内存划分为大小固定的小块，称为页框</td>
<td>内存划分为大小固定的小块，称为页框</td>
<td>内存未划分</td>
<td>内存未划分</td>
</tr>
<tr>
<td>程序被编译器或内存管理系统划分为页</td>
<td>程序被编译器或内存管理系统划分为页</td>
<td>由程序员给编译器指定程序段（即由程序员决定）</td>
<td>由程序员给编译器指定程序段（即由程序员决定）</td>
</tr>
<tr>
<td>页框中有内部碎片</td>
<td>页框中有内部碎片</td>
<td>无内部碎片</td>
<td>无内部碎片</td>
</tr>
<tr>
<td>无外部碎片</td>
<td>无外部碎片</td>
<td>有外部碎片</td>
<td>有外部碎片</td>
</tr>
<tr>
<td>操作系统须为每个进程维护一个页表，以说明每页对应的页框</td>
<td>操作系统须为每个进程维护一个页表，以说明每页对应的页框</td>
<td>操作系统须为每个进程维护一个段表，以说明每段中的加载地址和长度</td>
<td>操作系统须为每个进程维护一个段表，以说明每段中的加载地址和长度</td>
</tr>
<tr>
<td>操作系统须维护一个空闲页框列表</td>
<td>操作系统须维护一个空闲页框列表</td>
<td>操作系统须维护一个内存中的空闲空洞列表</td>
<td>操作系统须维护一个内存中的空闲空洞列表</td>
</tr>
<tr>
<td>处理器使用页号和偏移量来计算绝对地址</td>
<td>处理器使用页号和偏移量来计算绝对地址</td>
<td>处理器使用段号和偏移量来计算绝对地址</td>
<td>处理器使用段号和偏移量来计算绝对地址</td>
</tr>
<tr>
<td>进程运行时，它的所有页必须都在内存中，除非使用了覆盖技术</td>
<td>进程运行时，并非所有页都须在内存页框中。仅在需要时才读入页</td>
<td>进程运行时，其所有段都须在内存中，除非使用了覆盖技术</td>
<td>进程运行时，并非其所有段都须在内存中。仅在需要时才读入段</td>
</tr>
<tr>
<td></td>
<td>把一页读入内存可能需要把另一页写出到磁盘</td>
<td></td>
<td>把一段读入内存可能需要把另外一段或几段写出到磁盘</td>
</tr>
</tbody></table>
</blockquote>
<p><strong>系统抖动/系统颠簸（Thrashing）</strong>：当操作系统读入一个块时，必须将另一个块换出，如果被换出的块在不远的将来会用到，那么该块又会被重新换入。如果这种情况经常发生，导致处理器的大部分时间都用来处理交换块而非执行指令。这样的现象被称为系统抖动。</p>
<h3 id="局部性和虚拟内存"><a href="#局部性和虚拟内存" class="headerlink" title="局部性和虚拟内存"></a>局部性和虚拟内存</h3><p>虚存的优势确实很有吸引力，但是曾经对于虚存的方案有过争论，其关键点就在于进程块的切换：如何有效地加载部分块到内存中，以及避免系统抖动。但是局部性原理表明虚拟内存的方案是切实可行的。</p>
<p>局部性原理：</p>
<ul>
<li>一个进程中的程序和数据引用存在集簇倾向。</li>
<li>在一个很短的时间内仅需要进程的一部分块是合理的。</li>
<li>可以对未来可能会访问的块进行预测，从而避免系统抖动。</li>
</ul>
<p>事实上在众多操作系统的经验也已经证实了虚拟内存的可行性，但是要使虚存比较实用且有效，还需要两方面的因素：</p>
<ul>
<li>必须有对所采用分页或分段方案的硬件支持</li>
<li>操作系统必须能够管理页或段在内存和辅助存储器（简称：辅存）之间的移动</li>
</ul>
<h3 id="分页"><a href="#分页" class="headerlink" title="分页"></a>分页</h3><h4 id="页表"><a href="#页表" class="headerlink" title="页表"></a>页表</h4><ul>
<li><p>每个进程都有自己的页表</p>
</li>
<li><p><strong>页表项（Page Table Entry，PTE）</strong>包含有与内存中的页框相对应的页框号</p>
</li>
<li><p>每个页表项需要有一个P位来表示它所对应的页当前是否在内存中</p>
<blockquote>
<p>一个进程可能只有一部分页在内存中</p>
</blockquote>
</li>
<li><p>每个页表项需要有一个M位来表示相应页的内容从上次装入内存到现在是否已改变</p>
<ul>
<li>若未改变，则在需要把该页换出时，无须用页框中的内容更新该页（无需写入磁盘）</li>
</ul>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E5%88%86%E9%A1%B5%E9%A1%B9.png"></p>
</li>
</ul>
<p>地址转换系统：</p>
<p>从内存中读取一个字需要页表从虚拟地址（逻辑地址）到物理地址的转换</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%88%86%E9%A1%B5%E5%9C%B0%E5%9D%80%E8%BD%AC%E6%8D%A2%E7%B3%BB%E7%BB%9F.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li><p>虚拟地址/逻辑地址由页号和偏移量组成；物理地址由页框号和偏移量组成</p>
</li>
<li><p>当进程运行时，一个寄存器保存该进程页表的起始地址</p>
</li>
<li><p>虚拟地址的页号（Page #，n位）用于检索页表，以查找相应的页框号（Frame，m位）</p>
</li>
<li><p>查找到的页框号作为物理地址的页号，再与虚拟地址的偏移量结合起来形成最终的物理地址。（页框号|偏移量）</p>
<blockquote>
<ul>
<li>一般情况下，页号域长于页框号域（n &gt; m）</li>
<li>由于页表长度是变化的，因而不能期望在寄存器保存它。寄存器只能保存一个指向页表起始地址的页表指针（Page Table Rtr）</li>
</ul>
</blockquote>
</li>
</ul>
</blockquote>
<p>考虑这样一个情景：如果每个进程的虚存空间可达 2<sup>31</sup> = 2GB，如果页大小为 2<sup>9</sup> = 512字节，那么则每个进程需要 2<sup>31</sup> / 2<sup>9</sup> = 2<sup>22</sup> 个页表项。这反映出整个页表的大小与虚拟地址空间的大小成正比，而导致的后果就是：将耗费大量的内存空间去放置页表。</p>
<h4 id="两级层次页表"><a href="#两级层次页表" class="headerlink" title="两级层次页表"></a>两级层次页表</h4><p>为了解决这个问题，思考一下是否可以将页表也存储于虚拟内存中。于是有了两级层次页表的结构：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E4%B8%A4%E7%BA%A7%E5%B1%82%E6%AC%A1%E9%A1%B5%E8%A1%A8.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li><p>当一个进程正在运行时，它的页表至少有一部分须在内存中，这一部分包括正在运行的页的页表项</p>
</li>
<li><p>页目录：其中的每项指向一个页表</p>
<ul>
<li>如果页目录的长度为X，且一个页表的最大长度为Y，则一个进程可以有XY页</li>
</ul>
<blockquote>
<p>分析上图实例（用于32位地址的两级方案）：</p>
<ul>
<li>页大小为：4KB（2<sup>12</sup>）；虚拟地址空间大小为：4GB（2<sup>32</sup>）</li>
<li>则该虚拟地址空间由 2<sup>32</sup> / 2<sup>12</sup> = 2<sup>20</sup> 个页组成</li>
<li>规定每个页都由一个4字节的页表项映射，则可以创建一个由2<sup>20</sup>页组成的一个页表，这时需要2<sup>20</sup> × 2<sup>2</sup> = 2<sup>22</sup> = 4MB 的内存空间<ul>
<li>我们可以将这部分内容保留到虚存中，那么该部分虚拟内存空间又由2<sup>22</sup> / 2<sup>12</sup> = 2<sup>10</sup> 个页组成</li>
<li>这2<sup>10</sup> 个页又可以组成一个新的根页表，其占据的内存为：2<sup>10</sup> × 2<sup>2</sup> = 2<sup>12</sup> = 4KB</li>
</ul>
</li>
<li>如此一来，我们便可仅在内存中存放一个4KB大小的根页表，去访问一个4GB大小的虚拟内存中的数据</li>
</ul>
</blockquote>
</li>
</ul>
</blockquote>
<p>两级层次页表方案所对应的虚拟地址到物理地址的转换流程如下：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E4%B8%A4%E7%BA%A7%E5%B1%82%E6%AC%A1%E9%A1%B5%E8%A1%A8%E7%9A%84%E5%9C%B0%E5%9D%80%E8%BD%AC%E6%8D%A2.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li>虚拟地址的前10位用于检索根页表，查找关于用户页表的页的页表项<ul>
<li>若该页不在内存中，则发生一次缺页中断</li>
</ul>
</li>
<li>若该页在内存中，则用虚拟地址中接下来的10位检索用户页表项页，查找该虚拟地址引用的页的页表项</li>
<li>最终查找到的页框号作为物理地址的页号，再与虚拟地址的偏移量结合起来形成最终的物理地址。（页框号|偏移量）[同之前的方案一致]</li>
</ul>
</blockquote>
<h4 id="反向页表-倒排页表"><a href="#反向页表-倒排页表" class="headerlink" title="反向页表/倒排页表"></a>反向页表/倒排页表</h4><p>替代一级或多级页表的一种方法是，使用一个反向页表结构（Inverted Page Table）。</p>
<ul>
<li><p>虚拟地址的页号部分被映射成一个hash值 （散列函数映射），hash映射值构成一个散列表</p>
</li>
<li><p>hash值指向反向页表</p>
<blockquote>
<p>散列表包含指向反向表的指针，反向表中含有页表项</p>
</blockquote>
</li>
<li><p>得益于散列技术，多个虚拟地址可能映射到同一个散列表项中，可以减少表的容量</p>
<blockquote>
<p>多对一的映射关系可能导致数据访问冲突，但是也有相应的解决访问冲突的算法，这里先不考虑</p>
</blockquote>
<blockquote>
<p>页表结构称为“倒排/反向”的原因是，它使用页框号而非虚拟页号来索引页表项</p>
</blockquote>
</li>
</ul>
<p>反向页表的每项都包含如下内容：</p>
<ul>
<li><p>页号（Page number）：虚拟地址的页号部分</p>
</li>
<li><p>进程标识符（Process identifier）：使用该页的进程</p>
<blockquote>
<p>页号和进程标志符共同标志一个特定进程的虚拟地址空间的一页</p>
</blockquote>
</li>
<li><p>控制位（Control bits）：该域包含一些标记，比如有效、访问和修改，以及保护和锁定信息</p>
</li>
<li><p>链指针（Chain pointer）：</p>
<ul>
<li>若某项没有链项，则该域为空（或用一个单独的位来表示）</li>
<li>否则，该域包含链中下一项的索引值（0 ~ 页框数量-1 之间的数字）</li>
</ul>
</li>
</ul>
<blockquote>
<p>实例：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%80%92%E6%8E%92%E9%A1%B5%E8%A1%A8.png"></p>
<p>分析：</p>
<ul>
<li>物理内存中有2<sup>m</sup>个页框，反向页表包含2<sup>m</sup>项</li>
<li>虚拟地址前n位表示页号，且 n &gt; m</li>
<li>散列函数映射n位页号到m位数，用这m位数去索引反向页表</li>
<li>由此得页框号作为物理地址的页号，再与虚拟地址的偏移量结合起来形成最终的物理地址</li>
</ul>
</blockquote>
<h4 id="转移后备缓冲器-旁视缓冲器"><a href="#转移后备缓冲器-旁视缓冲器" class="headerlink" title="转移后备缓冲器/旁视缓冲器"></a>转移后备缓冲器/旁视缓冲器</h4><p>原则上，每次虚存访问都可能会引起两次物理内存访问：</p>
<ul>
<li>一次取相应的页表项</li>
<li>另一次取需要的数据</li>
</ul>
<p>因此，简单的虚拟内存方案会导致内存访问时间加倍。为了解决这个问题，引入转移后备缓冲器。</p>
<p><strong>转移后备缓冲器/旁视缓冲器（Translation Lookaside Buffer，TLB</strong>）：大多数虚拟内存方案都为页表项使用了一个特殊的高速缓存，它包含有最近用过的页表项。</p>
<p>具体虚拟地址转换为物理地址的流程如下：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%BD%AC%E7%A7%BB%E5%90%8E%E5%A4%87%E7%BC%93%E5%86%B2%E5%99%A8.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li><p>给定一个虚拟地址，处理器首先检查TLB</p>
<ul>
<li>若需要的页表项在其中（TLB命中），则检索页框号并形成实地址</li>
<li>若未找到需要的页表项（TLB未命中），则处理器用页号检索进程页表，并检查相应的页表项<ul>
<li>若“存在位”已置位（表示该页在内存中），处理器从页表项中检索页框号以形成实地址。同时更新TLB，使其包含这个新页表项。</li>
<li>若“存在位”未置位（表示该页不在内存中），这时会产生缺页故障中断，会去磁盘寻找数据。最后更新页表和TLB</li>
</ul>
</li>
</ul>
<p>详细流程见下图（包括关于缺页处理的细节）：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%BD%AC%E7%A7%BB%E5%90%8E%E5%A4%87%E7%BC%93%E5%86%B2%E5%99%A8%E6%B5%81%E7%A8%8B.png"></p>
</li>
</ul>
</blockquote>
<p>最后，虚拟存储机制需要与内存中的高速缓存进行交互（如下图）：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E8%99%9A%E5%AD%98%E4%B8%8E%E9%AB%98%E9%80%9F%E7%BC%93%E5%AD%98%E4%BA%A4%E4%BA%92.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li>内存系统查看TLB中是否存在匹配的页表项<ul>
<li>若存在，就组合页框号和偏移量，形成物理地址</li>
<li>若不存在，则从页表中读取页表项。产生由一个标记（tag）和其余部分组成的实地址后，查看高速缓存中是否存在包含这个字的块<ul>
<li>若有，则把它返回给CPU</li>
<li>若没有，则从内存中检索这个字</li>
</ul>
</li>
</ul>
</li>
</ul>
</blockquote>
<p>先来一个小梳理：</p>
<p>虚拟地址转换为实地址时，需要访问页表项，而页表项可能在TLB中，也可能在内存中或磁盘中，且被访问的字可能在高速缓存中、内存中或磁盘中。若被访问的字只在磁盘中，则包含该字的页必须装入内存，且它所在的块须装入高速缓存。此外，包含该字的页所对应的页表项必须更新。</p>
<h4 id="页尺寸"><a href="#页尺寸" class="headerlink" title="页尺寸"></a>页尺寸</h4><p>页尺寸是一个重要的硬件设计决策，它需要考虑多方面的因素：</p>
<ul>
<li>页越小，内部碎片的总量越少</li>
<li>页越小，每个进程需要的页的数量就越多，这就意味着更大的页表</li>
<li>对于大程序，活动进程有一部分页表在虚存而非内存中，从而导致一次内存访问可能产生两次缺页中断：<ul>
<li>第一次读取所需的页表部分</li>
<li>第二次读取进程页</li>
</ul>
</li>
<li>又基于大多数辅存设备的物理特性，为了实现更为有效的数据块传送，它们更希望页尺寸比较大</li>
</ul>
<p>页尺寸对缺页中断发生概率的影响使得这些问题变得更为复杂：</p>
<ul>
<li><p>如果页尺寸非常小，那么每个进程在内存中就有较多数量的页</p>
<p>一段时间后，内存中的页都包含有最近访问的部分，因此缺页率较低</p>
</li>
<li><p>当页尺寸增加时，每页包含的单元和任何一个最近访问过的单元越来越远（削弱局部性原理）</p>
<p>这会导致缺页率增长</p>
<p>但是，当页尺寸接近整个进程的大小时，缺页率开始下降。当一页包含整个进程时，不会发生缺页中断（如下图(a)，这很好理解）</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E9%A1%B5%E5%B0%BA%E5%AF%B8%E7%9A%84%E5%BD%B1%E5%93%8D.png"></p>
</li>
</ul>
<p>更为复杂的是，缺页率还取决于分配给一个进程的页框的数量（如上图(b)），该图表明：对固定的页尺寸，当内存中的页数量增加时，缺页率会下降（这也不难理解）</p>
<h3 id="分段"><a href="#分段" class="headerlink" title="分段"></a>分段</h3><ul>
<li><p>段的大小不等，并且是动态的</p>
</li>
<li><p>简化了对不断增长的数据结构的处理</p>
<blockquote>
<p>特定的数据结构（程序员并不知晓最后会变得多大）可以分配到它自己的段，需要时操作系统可以扩大或缩小这个段。</p>
<p>若扩大的段需要在内存中，且内存中已无足够的空间，操作系统则把这个段移到内存中的一个更大区域（如果可以得到），或把它换出。对于后一种情况，扩大的段会在下次有机会时换回。</p>
</blockquote>
</li>
<li><p>允许程序独立地改变或重新编译，而不要求整个程序集重新链接和重新加载</p>
</li>
<li><p>有助于进程间的共享</p>
<blockquote>
<p>程序员可以在段中放置一个实用工具程序或一个有用的数据表，供其他进程访问</p>
</blockquote>
</li>
<li><p>有助于保护</p>
<blockquote>
<p>由于一个段可被构造成包含一个明确定义的程序或数据集，因而程序员或系统管理员可以更方便地指定访问权限</p>
</blockquote>
</li>
</ul>
<p>每个进程都有自己的段表，每个段表项包含：</p>
<ul>
<li><p>相应段在内存中的起始地址（段基址）</p>
</li>
<li><p>段的长度</p>
</li>
<li><p>有一个P位来表示它所对应的段当前是否在内存中</p>
</li>
<li><p>有一个M位来表示相应段的内容从上次装入内存到现在是否已改变</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E8%A1%A8%E7%9A%84%E7%BB%93%E6%9E%84.png"></p>
</li>
</ul>
<p>虚拟地址到物理地址的转换：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E7%9A%84%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E5%88%B0%E7%89%A9%E7%90%86%E5%9C%B0%E5%9D%80%E7%9A%84%E8%BD%AC%E6%8D%A2.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li>当一个进程正在运行时，有一个寄存器为该进程保存段表的起始地址</li>
<li>虚拟地址中的段号（Seg #）用于检索段表，查找得到该段起始点的相应的内存地址（Base）</li>
<li>将得到的基地址与虚拟地址中的偏移量（offset）相加，得到最终的物理地址</li>
</ul>
</blockquote>
<h3 id="段页式"><a href="#段页式" class="headerlink" title="段页式"></a>段页式</h3><p>分页和分段各有优势：</p>
<ul>
<li>分页对程序员是透明的，它消除了外部碎片，因而能更有效地使用内存</li>
<li>分段对程序员是可见的，它具有处理不断增长的数据结构的能力，及支持共享和保护的能力</li>
</ul>
<p>结合这二者的优点，引出了段页式结构。</p>
<p>先来介绍段表项以及页表项的结构：</p>
<ul>
<li><p>段表项：</p>
<ul>
<li>包含段的长度</li>
<li>包含一个指向一个页表的基域</li>
<li>无存在位和修改位</li>
</ul>
</li>
<li><p>页表项：</p>
<ul>
<li>与纯粹的分页系统中的页表项相同</li>
</ul>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E9%A1%B5%E5%BC%8F%E8%A1%A8%E9%A1%B9.png"></p>
</li>
</ul>
<p>虚拟地址到物理地址的转化：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%AE%B5%E9%A1%B5%E5%BC%8F%E8%99%9A%E6%8B%9F%E5%9C%B0%E5%9D%80%E8%BD%AC%E7%89%A9%E7%90%86%E5%9C%B0%E5%9D%80.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li>当一个进程正在运行时，使用一个寄存器记录该进程段表的起始地址</li>
<li>处理器利用虚拟地址中的段号（Seg #）来检索进程段表以寻找该段的页表</li>
<li>虚拟地址中的页号（page #）用于检索页表并查找相应的页框号</li>
<li>最后得到的页框号就是物理地址的页号，结合虚拟地址的偏移量，得到最终的物理地址</li>
</ul>
</blockquote>
<h3 id="保护和共享"><a href="#保护和共享" class="headerlink" title="保护和共享"></a>保护和共享</h3><blockquote>
<p>分段有助于实现保护与共享机制。由于每个段表项包括一个长度和一个基地址，因而程序不会不经意地访问超出该段的内存单元。为实现共享，一个段可能会在多个进程的段表中引用。当然，在分页系统中也可得到同样的机制。但是，这种情况下由于程序的页结构和数据对程序员不可见，因此更难说明共享和保护需求。（下图说明了这类系统中可以实施的保护关系的类型）</p>
<img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS保护与共享.png" style="zoom:80%;" />
</blockquote>
<h2 id="操作系统软件"><a href="#操作系统软件" class="headerlink" title="操作系统软件"></a>操作系统软件</h2><p>在实现内存管理的时候，需要考虑三方面的因素：</p>
<ul>
<li>是否支持虚拟存储</li>
<li>虚拟存储的具体实现方式（分页、分段、段页式）</li>
<li>操作系统在内存分配时的具体算法</li>
</ul>
<p>前两个因素取决于硬件部分，而第三个因素属于操作系统软件领域的问题，以下将会介绍虚拟存储考虑的六种策略。</p>
<h3 id="读取策略"><a href="#读取策略" class="headerlink" title="读取策略"></a>读取策略</h3><p>读取策略（Fetch Policy）决定一个页何时被取入内存，常用到的有以下两种方法：</p>
<ul>
<li><p>请求分页式（Demand paging）：只有当访问到某页中的一个单元时才将该页取入内存。</p>
<ul>
<li><p>当一个进程首次启动时，会在一段时间出现大量的缺页中断</p>
<blockquote>
<p>取入越来越多的页后，局部性原理表明大多数将来访问的页都是最近读取的页。因此，在一段时间后错误会逐渐减少，缺页中断的数量会降到很低。</p>
</blockquote>
</li>
</ul>
</li>
<li><p>预约分页式（Prepaging）：启动进程时一次读取页的数量要比实际需要访问的多。</p>
<ul>
<li><p>更为有效的做法是一次读取辅存设备（如磁盘）中连续的页</p>
<blockquote>
<p>由于该策略本身的原因，可能会导致大部分读取的页执行进程不会访问，在这种情况下该策略其实是低效的。</p>
</blockquote>
</li>
</ul>
</li>
</ul>
<p>为了有效地提高效率，可以采用两种策略相结合的方式：在进程首次启动时以及发生缺页中断时采用预约分页式策略，在正常执行时采用请求分页式策略。</p>
<h3 id="放置策略"><a href="#放置策略" class="headerlink" title="放置策略"></a>放置策略</h3><p>放置策略（Placement Policy）决定一个进程块驻留在实存中的什么位置。</p>
<ul>
<li><p>在分段系统以及非一致存储访问（NonUniform Memory Access，NUMA）系统中很重要</p>
</li>
<li><p>对于分页和段页式系统，放置策略通常无关紧要</p>
<blockquote>
<p>地址转换硬件和内存访问硬件能以相同的效率为任何页框组合执行相应的功能，因此分页和段页式系统对于放置不敏感</p>
</blockquote>
</li>
</ul>
<h3 id="置换策略"><a href="#置换策略" class="headerlink" title="置换策略"></a>置换策略</h3><p>当内存已满，在进程必须读取一个新页时，不得不置换出内存中的一页，关于如何置换页，置换策略（Replacement Policy）给出了一些方法。</p>
<p>首先我们要考虑置换页时，我们应该选择哪些页被换出：</p>
<ul>
<li><p>置换的目标应该聚焦在那些在未来一段时间内不会被进程访问到或是访问次数很少的页（这不难理解）</p>
<blockquote>
<p>这里需要声明一点（包括在以后的章节中也有此类问题）：关于未来进程的执行需要哪些访问，程序员以及操作系统都是无法预测的。</p>
<p>（很多设计之初是这样的，在最开始有一个理想的目标或定位。但是在实现起来却发现在实际操作中会遇到致命的问题。要么采用一些手段去想办法解决，要么退而求其次，修改一下目标实现）</p>
</blockquote>
</li>
<li><p>大多数策略都基于过去的行为来预测将来的行为</p>
<blockquote>
<p>好在智慧的人们总结出来这么一条规律：以历史去推测未来。</p>
<p>局部性原理告诉我们：最近的访问历史和最近将要访问的模式间有很大的相关性。</p>
<p>（既然我们无法站在现在去预测未来，那我们就站在历史的角度去观测现在）</p>
</blockquote>
</li>
<li><p>值得注意的是，置换策略设计得越精致、越复杂，实现它的软硬件开销就越大</p>
</li>
</ul>
<h3 id="页框锁定"><a href="#页框锁定" class="headerlink" title="页框锁定"></a>页框锁定</h3><p>在置换页时需要注意的是，置换策略有一个约束条件——页框锁定（Frame Locking）。</p>
<p>内存中的某些页框可能是被锁定的，当一个页框被锁定时，当前保存在该页框中的页就不能被置换。例如以下内容：</p>
<ul>
<li>操作系统的内核</li>
<li>重要的控制结构</li>
<li>I/O缓冲区以及一些其他对时间要求严格的区域</li>
</ul>
<p>锁定是通过给每个页框关联一个“锁定”位实现的，这一位可以包含在页框表和当前的页表中。</p>
<p>基本算法：不论采用哪种驻留集管理策略，都有一些用于选择置换页的基本算法。包括以下四种：</p>
<ul>
<li>最佳（Optimal policy，OPT）</li>
<li>最近最少使用（Least Recently Used ，LRU）</li>
<li>先进先出（First In First Out，FIFO）</li>
<li>时钟（Clock）</li>
</ul>
<h4 id="最佳（OPT）"><a href="#最佳（OPT）" class="headerlink" title="最佳（OPT）"></a>最佳（OPT）</h4><p>OPT策略选择置换下次访问距当前时间最长的那些页。</p>
<ul>
<li>这种算法导致的缺页中断最少</li>
<li>但是要求操作系统需要预测未来访问</li>
</ul>
<h4 id="最近最少使用（LRU）"><a href="#最近最少使用（LRU）" class="headerlink" title="最近最少使用（LRU）"></a>最近最少使用（LRU）</h4><p>LRU策略选择置换内存中最长时间未被引用的页。</p>
<blockquote>
<p>如何理解“最近最少使用”：即在短时间的未来最少被进程访问的页。</p>
<p>同样根据局部性原理，在内存中最长时间未被引用的页，也是短时间内未来最不可能访问到的页。</p>
</blockquote>
<p>实现方法是：</p>
<ol>
<li>给每页添加一个最后一次访问的时间戳，并在每次访问内存时更新这个时间戳。<ul>
<li>这种方案需要硬件的支持，会造成大量的开销</li>
</ul>
</li>
<li>维护一个关于访问页的栈<ul>
<li>依然会造成大量的开销</li>
</ul>
</li>
</ol>
<h4 id="先进先出（FIFO）"><a href="#先进先出（FIFO）" class="headerlink" title="先进先出（FIFO）"></a>先进先出（FIFO）</h4><p>将分配给进程的一个页框视为一个循环缓冲区，以顺次循环的方式替换页。</p>
<ul>
<li>只需要一个指针，该指针在进程的页框中循环</li>
<li>这是最简单的一种算法</li>
<li>该方法会将驻留在内存中最久的页替换出去，但是有可能该页会在未来的不久被访问到</li>
</ul>
<h4 id="时钟策略（Clock）"><a href="#时钟策略（Clock）" class="headerlink" title="时钟策略（Clock）"></a>时钟策略（Clock）</h4><p>给每一个页框关联一个称为<code>使用位</code>的附加位，整个缓冲区（也是循环的）有一个指针：</p>
<ul>
<li><p>当一个页首次被加入到内存中时，使用位被置为1（首次加载当然会被访问）</p>
<ul>
<li>随后被访问到（在访问产生缺页中断后）时也会置为1。（简单讲：只要被进程访问，使用位就置位1）</li>
</ul>
</li>
<li><p>当一个页面被置换时，指针指向缓冲区的下一个页框</p>
</li>
<li><p>考虑如何置换（进程的页框已被占满）：</p>
<ul>
<li>需要置换一页时，操作系统从指针指向的页框顺次扫描整个缓冲区，如果找到第一个使用位为0的页框，就将该页置换出去，并将使用位置为1，指针指向下一个页框</li>
<li>在指针扫描过程中，如果遇到使用位为1的页框，将其置为0，继续扫描，直到找到使用位为0的页框，进行替换</li>
<li>缓冲区是循环的，用图像具象化展示该种策略也不难理解为什么称之为时钟策略</li>
</ul>
<blockquote>
<p>具体实例如下图：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E6%97%B6%E9%92%9F%E7%AD%96%E7%95%A5%E7%BD%AE%E6%8D%A2.png"></p>
</blockquote>
</li>
</ul>
<p>下图给出了四种策略的例子：</p>
<ul>
<li>假设该程序所需要的页地址顺序为：2、3、2、1、5、2、4、5、3、2、5、2</li>
<li>假设为该进程分配了3个页框（驻留集大小固定）</li>
</ul>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E7%BD%AE%E6%8D%A2%E7%AD%96%E7%95%A5%E5%AE%9E%E4%BE%8B.png"></p>
<blockquote>
<p>说明：</p>
<ul>
<li><strong>F</strong> 表示产生缺页中断</li>
<li>始终策略中：有符号<code>*</code>表示该页框的使用位被置位1，没有标记则表示0</li>
</ul>
</blockquote>
<p>针对上述四种算法的相关实验结果如下图：</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%9B%9B%E7%A7%8D%E7%BD%AE%E6%8D%A2%E7%AE%97%E6%B3%95%E7%9A%84%E5%AE%9E%E9%AA%8C.png"></p>
<blockquote>
<p>说明：假设分配给一个进程的页框数量是固定的。该实验结果基于在一个FORTRAN程序中执行 0.25 × 10<sup>6</sup>次访问，页尺寸为256个字</p>
<ul>
<li>纵轴表示每1000次访问的缺页；横轴表示分配的页框数</li>
<li>当分配的页框比较少时，四种策略的差别非常显著</li>
<li>结果表明，为了更高效的执行，我们希望：<ul>
<li>能处于拐点的右侧（即缺页率小）</li>
<li>同时又希望处于拐点左侧（即保证小页框的分配）</li>
<li>因此表明需要的操作模式应位于曲线的拐点处</li>
</ul>
</li>
</ul>
</blockquote>
<h4 id="增强型时钟"><a href="#增强型时钟" class="headerlink" title="增强型时钟"></a>增强型时钟</h4><p>之前讨论的算法中，只考虑到了如何置换，而当页被修改时，并未讨论。</p>
<p>基于时钟策略，考虑到页修改的情况，于是有了增强型时钟策略：在原有使用位的基础上，新增添了一个修改位。</p>
<blockquote>
<p>修改位是必须的，若某页被修改，则在它被写回外存前不会被置换出。</p>
</blockquote>
<p>考虑以下四种情形（使用位用<code>u</code>表示，修改位用<code>m</code>表示）：</p>
<ol>
<li>最近未被访问，也未被修改（u=0；m=0）</li>
<li>最近被访问，但未被修改（u=1；m=0）</li>
<li>最近未被访问，但被修改（u=0；m=1）</li>
<li>最近被访问，且被修改（u=1；m=1）</li>
</ol>
<p>根据以上分类，时钟算法对于使用位的策略不变，具体流程如下：</p>
<ul>
<li>先扫描<code>u=0；m=0</code>的页，如果遇到，则置换该页</li>
<li>若上一步失败，则扫描<code>u=1；m=0</code>的页，如果遇到，则置换该页</li>
<li>若上一步失败，则返回第一步（指针回到其最初的位置），此时便有u=0的页了</li>
</ul>
<h4 id="页缓冲"><a href="#页缓冲" class="headerlink" title="页缓冲"></a>页缓冲</h4><p>考虑开销的问题，无疑FIFO的策略是最简单的，但是很明显它可能造成抖动，这是不被接受的。于是在考虑能否以FIFO策略为基础提出一种改进算法，这便有了页缓冲（Page Buffering）。</p>
<ul>
<li><p>提供了两个表，当页发生置换时：</p>
<ul>
<li>若页未被修改，则分配到空闲页表（Free page list）中</li>
<li>若已被修改，则分配到修改页表（Modified page list）中</li>
</ul>
<blockquote>
<ul>
<li>这些操作的一个重要特点是，被置换的页仍然留在内存中。因此，若进程访问该页，则可迅速返回该进程的驻留集，且代价很小。</li>
<li>实际上，空闲页链表和修改页链表充当着页的高速缓存的角色。</li>
<li>修改页表还有另外一种很有用的功能：已修改的页按簇写回，而不是一次只写一页，因此大大减少了I/O操作的数量，进而减少了磁盘访问时间。</li>
</ul>
</blockquote>
</li>
</ul>
<h4 id="高速缓存"><a href="#高速缓存" class="headerlink" title="高速缓存"></a>高速缓存</h4><p>置换策略和高速缓存大小如前所述，随着内存越来越大，应用的局部性特性逐渐降低。作为补偿，高速缓存的大小也相应增加。较大的高速缓存，甚至是几兆字节的高速缓存，现在也是合理的设计选择。</p>
<h3 id="驻留集管理"><a href="#驻留集管理" class="headerlink" title="驻留集管理"></a>驻留集管理</h3><h4 id="驻留集大小"><a href="#驻留集大小" class="headerlink" title="驻留集大小"></a>驻留集大小</h4><p>驻留集（Resident Set）大小对于分页式虚拟内存，在准备执行时，不需要也不可能把一个进程的所有页都读入内存。因此，操作系统必须决定读取多少页，即决定给特定的进程分配多大的内存空间。这需要考虑以下几个因素：</p>
<ul>
<li><p>分配给一个进程的内存越少，在任何时候驻留在内存中的进程数就越多。</p>
<blockquote>
<p>这增加了操作系统至少找到一个就绪进程的可能性，减少了由于交换而消耗的处理器时间。</p>
</blockquote>
</li>
<li><p>若一个进程在内存中的页数较少，尽管有局部性原理，缺页率仍相对较高。</p>
</li>
<li><p>给特定进程分配的内存空间超过一定大小后，由于局部性原理，该进程的缺页率没有明显的变化。</p>
</li>
</ul>
<p>基于以上因素，当代操作系统通常采取以下两种策略：</p>
<ul>
<li><p>固定分配策略（Fixed-allocation）：</p>
<ul>
<li>在进程执行时，为其在内存中分配固定数量的页框（这一数量在进程创建时就被确定）</li>
<li>一旦在进程的执行过程中发生缺页中断，该进程的一页就必须被它所需要的页面置换</li>
</ul>
</li>
<li><p>可变分配策略（Variable-allocation）：</p>
<ul>
<li><p>允许分配给一个进程的页框在该进程的生命周期中不断地发生变化。</p>
<blockquote>
<p>理论上：</p>
<ul>
<li>若一个进程的缺页率一直比较高，则表明在该进程中局部性原理表现较弱，应给它多分配一些页框以减小缺页率；</li>
<li>若一个进程的缺页率特别低，则表明从局部性的角度看该进程的表现非常好，可在不明显增大缺页率的前提下减少分配给它的页框。</li>
</ul>
</blockquote>
<blockquote>
<p>看起来的优势策略必然会导致开销：可变分配策略要求操作系统对活动进程进行评估；除此之外还包括硬件上的开销。</p>
</blockquote>
</li>
</ul>
</li>
</ul>
<h4 id="置换范围"><a href="#置换范围" class="headerlink" title="置换范围"></a>置换范围</h4><p>置换策略的范围分为以下两类：</p>
<ul>
<li>局部置换策略（Local Replace Policy）：在替换页时，仅在产生这次缺页的进程的驻留页中选择。</li>
<li>全局置换策略（Global Replace Policy）：把内存中所有未被锁定的页都作为置换的候选页，而不管它们属于哪个进程。</li>
</ul>
<p>置换范围和驻留集大小之间存在一定的联系（如下表）：</p>
<table>
<thead>
<tr>
<th></th>
<th>局部置换</th>
<th>全局置换</th>
</tr>
</thead>
<tbody><tr>
<td><strong>固定分配</strong></td>
<td>分配给一个进程的页框数是固定的<br>从分配给该进程的页框中选择被置换的页</td>
<td>无此方案</td>
</tr>
<tr>
<td><strong>可变分配</strong></td>
<td>分配给一个进程的页框数不时变化，用于保存该进程的工作集<br>从分配给该进程的页框中选择被置换的页</td>
<td>从内存中的所有可用页框中选择被置换的页；这将导致进程驻留集的大小不断变化</td>
</tr>
</tbody></table>
<p>下面来一一详细介绍：</p>
<h4 id="固定分配、局部置换"><a href="#固定分配、局部置换" class="headerlink" title="固定分配、局部置换"></a>固定分配、局部置换</h4><p>分配给在内存中运行的进程的页框数固定</p>
<ul>
<li>总页数分配得过少时，会产生很高的缺页率</li>
<li>总页数分配得过多时，内存中只能有很少的几个程序，处理器会有很多空闲时间，并把大量时间花费在交换上</li>
</ul>
<h4 id="可变分配、全局置换"><a href="#可变分配、全局置换" class="headerlink" title="可变分配、全局置换"></a>可变分配、全局置换</h4><ul>
<li>该种组合方式最容易实现，并被许多操作系统使用</li>
<li>操作系统除了为每个进程分配了一定数量的页框，还维护有一个空闲页框列表，发生一次缺页中断时，一个空闲页框会被添加到进程的驻留集，并读入该页。因此发生缺页中断的进程的大小会逐渐增大<ul>
<li>如果没有空闲页框可用时，操作系统必须选择一个当前位于内存中的页框进行置换（不包括被锁定的页框）</li>
</ul>
</li>
</ul>
<blockquote>
<p>问题：选择的置换页可以属于任何一个驻留进程，而没有任何原则用于确定哪个进程应从其驻留集中失去一页。因此，驻留集大小减小的那个进程可能并不是最适合被置换的。</p>
<p>解决此问题的一种方法是使用页缓冲：按照这种方法，选择置换哪一页并不重要，因为如果在下次重写这些页之前访问到了这一页，则这一页仍可回收。</p>
</blockquote>
<h4 id="可变分配、局部置换"><a href="#可变分配、局部置换" class="headerlink" title="可变分配、局部置换"></a>可变分配、局部置换</h4><p>为了解决可变分配、全局置换的潜在问题，引入了另一种组合：可变分配、局部置换。</p>
<ul>
<li>当一个新进程被装入内存时，根据应用类型、程序要求或其他原则，给它分配一定数量的页框作为其驻留集<ul>
<li>使用预先分页或请求分页填满这些页框</li>
</ul>
</li>
<li>发生一次缺页中断时，从产生缺页中断的进程的驻留集中选择一页用于置换</li>
<li>不时地重新评估进程的页框分配情况，增加或减少分配给它的页框，以提高整体性能</li>
</ul>
<h3 id="清除策略"><a href="#清除策略" class="headerlink" title="清除策略"></a>清除策略</h3><p>与读取策略相反，清除策略（Clearing Policy）用于确定何时将已修改的一页写回辅存，通常有以下两种选择：</p>
<ul>
<li><p>请求式清除（Demand cleaning）：只有当页被选择用于置换时才被写回辅存。</p>
</li>
<li><p>预约式清除（Precleaning）：将这些已修改的多页在需要使用它们所占据的页框之前成批写回辅存。</p>
<blockquote>
<p>分析：</p>
<p>完全使用任何一种策略都存在问题：</p>
<ul>
<li>对于请求式清除：写回已修改的页和读入新页是成对出现的，且写回在读入之前。这就意味着当发生缺页中断的进程在解除阻塞之前必须等待两次页传送，可能降低处理器效率。</li>
<li>对于预约式清除：需要被写回辅存的页可能仍然留在内存中，直到页面置换算法指示它被移出。预约式清除允许成批地写回页，但是这样意义不大，因为这些页中地大部分通常在置换前又被修改。</li>
</ul>
</blockquote>
</li>
</ul>
<p>由于单纯使用某一种策略都会有潜在的问题，一种比较好的方式就是结合页缓冲技术。具体策略：只清除可用于置换的页，但去除了清除和置换操作间的成对关系。</p>
<ul>
<li>被置换的页会放在如下两个页表中：<ul>
<li>修改表：修改表中的页可以周期性地成批写出，并移入未修改表中。</li>
<li>未修改表：未修改表中的一页要么因为被重新访问而被回收，要么在其页框分配给另一页时被淘汰。</li>
</ul>
</li>
</ul>
<h3 id="加载控制"><a href="#加载控制" class="headerlink" title="加载控制"></a>加载控制</h3><p>加载控制（Load Control）会影响到驻留在内存中的进程数量，这称为系统并发度。</p>
<p>如何控制系统并发度是一个值得思考的问题，因为有以下两种情况影响着处理器利用率：</p>
<ul>
<li><p>如果驻留进程太少，那么所有进程都处于阻塞态的概率就较大。</p>
</li>
<li><p>如果驻留进程太多，那么平均每个进程的驻留集大小将会不够用，此时会频繁发生缺页中断，导致系统抖动。</p>
<p><img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/OS%E5%B9%B6%E5%8F%91%E5%BA%A6%E5%A4%A7%E5%B0%8F.png"></p>
<blockquote>
<p>最好能够保证并发度达到图中虚线位置，使处理器效率达到最大</p>
<blockquote>
<p>工作集或PFF算法都隐含了加载控制。</p>
<ul>
<li>只允许执行那些驻留集足够大的进程。</li>
<li>在为每个活动进程提供需要的驻留集大小时，该策略会自动并动态地确定活动程序的数量。</li>
</ul>
</blockquote>
</blockquote>
</li>
</ul>
<h4 id="进程挂起"><a href="#进程挂起" class="headerlink" title="进程挂起"></a>进程挂起</h4><p>系统并发度减小时，一个或多个当前驻留进程须被挂起（换出）。具体为以下六种情况：</p>
<ul>
<li><p>最低优先级进程：实现调度策略决策，与性能问题无关。</p>
</li>
<li><p>缺页中断进程：原因在于很有可能是缺页中断任务的工作集还未驻留，因而挂起它对性能的影响最小。</p>
<blockquote>
<p>此外，由于它阻塞了一个一定会被阻塞的进程，并且消除了页面置换和I/O操作的开销，因而该选择可以立即收到成效。</p>
</blockquote>
</li>
<li><p>最后一个被激活的进程：这个进程的工作集最有可能还未驻留。</p>
</li>
<li><p>驻留集最小的进程：在将来再次装入时的代价最小，但不利于局部性较小的程序。</p>
</li>
<li><p>最大空间的进程：可在过量使用的内存中得到最多的空闲页框，使它不会很快又处于去活（deactivation）状态。</p>
</li>
<li><p>具有最大剩余执行窗口的进程：在大多数进程调度方案中，一个进程在被中断或放置在就绪队列末尾之前，只运行一定的时间。这近似于最短处理时间优先的调度原则。</p>
</li>
</ul>
<hr>
<h1 id="后记"><a href="#后记" class="headerlink" title="后记"></a>后记</h1><p>本篇已完结</p>
<p><em>通过本章细细品味一下操作系统为何在计算机学课中是具有那么一些哲学味道的学课</em>🤔🤔🤔🤔</p>
<p>（如有修改或补充欢迎评论）</p>

    </div>

    
    
    
      
  <div class="popular-posts-header">相关文章</div>
  <ul class="popular-posts">
    <li class="popular-posts-item">
      <div class="popular-posts-title"><a href="\next\2021\03\28\操作系统\操作系统学习笔记\" rel="bookmark">操作系统学习笔记</a></div>
    </li>
    <li class="popular-posts-item">
      <div class="popular-posts-title"><a href="\next\2021\06\09\操作系统\操作系统学习笔记-文件管理\" rel="bookmark">操作系统学习笔记-文件管理</a></div>
    </li>
    <li class="popular-posts-item">
      <div class="popular-posts-title"><a href="\next\2021\06\02\操作系统\操作系统学习笔记-I-O管理和磁盘调度\" rel="bookmark">操作系统学习笔记-I/O管理和磁盘调度</a></div>
    </li>
    <li class="popular-posts-item">
      <div class="popular-posts-title"><a href="\next\2021\05\30\操作系统\操作系统学习笔记-单处理器调度\" rel="bookmark">操作系统学习笔记-单处理器调度</a></div>
    </li>
    <li class="popular-posts-item">
      <div class="popular-posts-title"><a href="\next\2021\05\23\操作系统\操作系统学习笔记-内存管理\" rel="bookmark">操作系统学习笔记-内存管理</a></div>
    </li>
  </ul>


    <footer class="post-footer">
          <div class="reward-container">
  <div></div>
  <button>
    赞赏
  </button>
  <div class="post-reward">
      <div>
        <img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/wechat.png" alt="花猪 微信">
        <span>微信</span>
      </div>
      <div>
        <img src="https://cdn.jsdelivr.net/gh/CNhuazhu/Image/alipay.jpg" alt="花猪 支付宝">
        <span>支付宝</span>
      </div>

  </div>
</div>

          <div class="post-tags">
              <a href="/next/tags/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/" rel="tag"><i class="fa fa-tag"></i> 操作系统</a>
          </div>

        

          <div class="post-nav">
            <div class="post-nav-item">
                <a href="/next/2021/05/23/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E5%86%85%E5%AD%98%E7%AE%A1%E7%90%86/" rel="prev" title="操作系统学习笔记-内存管理">
                  <i class="fa fa-chevron-left"></i> 操作系统学习笔记-内存管理
                </a>
            </div>
            <div class="post-nav-item">
                <a href="/next/2021/05/30/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F%E5%AD%A6%E4%B9%A0%E7%AC%94%E8%AE%B0-%E5%8D%95%E5%A4%84%E7%90%86%E5%99%A8%E8%B0%83%E5%BA%A6/" rel="next" title="操作系统学习笔记-单处理器调度">
                  操作系统学习笔记-单处理器调度 <i class="fa fa-chevron-right"></i>
                </a>
            </div>
          </div>
    </footer>
  </article>
</div>






    <div class="comments"><div id="twikoo-comments"></div></div>
</div>
  </main>

  <footer class="footer">
    <div class="footer-inner">


<div class="copyright">
  &copy; 
  <span itemprop="copyrightYear">2021</span>
  <span class="with-love">
    <i class="fa fa-heart"></i>
  </span>
  <span class="author" itemprop="copyrightHolder">花猪</span>
</div>
<div class="wordcount">
  <span class="post-meta-item">
    <span class="post-meta-item-icon">
      <i class="fa fa-chart-line"></i>
    </span>
      <span>站点总字数：</span>
    <span title="站点总字数">356k</span>
  </span>
  <span class="post-meta-item">
    <span class="post-meta-item-icon">
      <i class="fa fa-coffee"></i>
    </span>
      <span>站点阅读时长 &asymp;</span>
    <span title="站点阅读时长">5:23</span>
  </span>
</div>
  <div class="powered-by">由 <a href="https://hexo.io/" rel="noopener" target="_blank">Hexo</a> & <a href="https://theme-next.js.org/mist/" rel="noopener" target="_blank">NexT.Mist</a> 强力驱动
  </div>

    </div>
  </footer>

  
  <script src="https://cdn.jsdelivr.net/npm/animejs@3.2.1/lib/anime.min.js" integrity="sha256-XL2inqUJaslATFnHdJOi9GfQ60on8Wx1C2H8DYiN1xY=" crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/@next-theme/pjax@0.5.0/pjax.min.js" integrity="sha256-3NkoLDrmHLTYj7csHIZSr0MHAFTXth7Ua/DDt4MRUAg=" crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/jquery@3.6.0/dist/jquery.min.js" integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@3.5.7/dist/jquery.fancybox.min.js" integrity="sha256-yt2kYMy0w8AbtF89WXb2P1rfjcP/HTHLT7097U8Y5b8=" crossorigin="anonymous"></script>
  <script src="https://cdn.jsdelivr.net/npm/medium-zoom@1.0.6/dist/medium-zoom.min.js" integrity="sha256-EdPgYcPk/IIrw7FYeuJQexva49pVRZNmt3LculEr7zM=" crossorigin="anonymous"></script>
<script src="/next/js/comments.js"></script><script src="/next/js/utils.js"></script><script src="/next/js/motion.js"></script><script src="/next/js/schemes/muse.js"></script><script src="/next/js/next-boot.js"></script><script src="/next/js/pjax.js"></script>

  
<script src="/next/js/third-party/search/local-search.js"></script>




  


  <script class="next-config" data-name="leancloud_visitors" type="application/json">{"enable":true,"app_id":"dh8GVAcIwU1TN4zhA5y63iW1-gzGzoHsz","app_key":"hzyAqDKjG4OBGrdPS7mKaOa7","server_url":null,"security":true}</script>
  <script src="/next/js/third-party/statistics/lean-analytics.js"></script>


  

  <script class="next-config" data-name="enableMath" type="application/json">true</script><script class="next-config" data-name="mathjax" type="application/json">{"enable":true,"tags":"none","js":{"url":"https://cdn.jsdelivr.net/npm/mathjax@3.2.0/es5/tex-mml-chtml.js","integrity":"sha256-r+3itOMtGGjap0x+10hu6jW/gZCzxHsoKrOd7gyRSGY="}}</script>
<script src="/next/js/third-party/math/mathjax.js"></script>


<script class="next-config" data-name="twikoo" type="application/json">{"enable":true,"visitor":true,"envId":"hexo-1g41404w9f800e94","el":"#twikoo-comments"}</script>
<script>
document.addEventListener('page:loaded', () => {
  NexT.utils.loadComments(CONFIG.twikoo.el)
    .then(() => NexT.utils.getScript(
      'https://cdn.jsdelivr.net/npm/twikoo/dist/twikoo.all.min.js',
      { condition: window.twikoo }
    ))
    .then(() => {
      twikoo.init(CONFIG.twikoo);
    });
});
</script>

</body>
</html>
